用栈解迷宫问题

/**************************************************************************************
 用数组栈解决迷宫问题
 1. 在maze[][]二维数组中，0表示通道，1表示墙壁
 2. 在FootPrints[][]二维数组中，{-1,-1}表示未经过，非{-1,-1}表示经过的点

整体思路如下：

将起点标记为已走过并压栈;
while (栈非空)
{
    从栈顶弹出一个点p;
    if (p这个点是终点)
    {
        break;
    }

   否则沿下、右、上、左四个方向探索相邻的点
    if (和p相邻的点有路可走，并且还没走过)
    {
        将相邻的点标记为已走过并压栈，且记录它的前趋点-->p点坐标;
    }
}
if (p点是终点)
{
     打印p点的坐标;
    while (p点有前趋)
    {
        p点 = p点的前趋;
        打印p点的坐标;
    }
}
else
{
    没有路线可以到达终点;
}

***************************************************************************************/

#include <stdio.h>

#define MAX_ROW    8
#define MAX_COL    8

typedef struct point
{
    int row;
    int col;
}Point;

int maze[MAX_ROW][MAX_COL] = {
    0, 1, 0, 1, 0, 0, 1, 0,
    0, 0, 1, 0, 1, 0, 0, 1,
    0, 0, 0, 0, 1, 1, 1, 1,
    1, 0, 1, 0, 1, 0, 0, 1,
    1, 0, 1, 0, 0, 1, 1, 1,
    1, 1, 1, 0, 0, 0, 0, 1,
    0, 0, 0, 0, 0, 1, 1, 1,
    1, 1, 1, 1, 0, 0, 0, 0,
};

Point FootPrints[MAX_ROW][MAX_COL] = {
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
{{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
};

Point stack[MAX_ROW * MAX_COL];
unsigned    int top = 0;

int StackFull(void)
{
    return    top == MAX_ROW * MAX_COL;
}

int StackEmpty(void)
{
    return    top == 0;
}

void Push(Point p)
{
    if(! StackFull())
    {
        stack[top++] = p;
    }
    else
    {
        printf("stack is full ! \n");
    }
}

Point Pop(void)
{
    if(! StackEmpty())
    {
        return    stack[--top];
    }
    else
    {
        printf("stack is empty ! \n");
    }
}

void VisitedPoint(int row, int col, Point p)/*记录访问过的点，入栈并且记录上一个点的坐标*/
{
    Point tempPoint;

    tempPoint.row = row;
    tempPoint.col = col;
    
    maze[row][col] = 2;/*访问过的点符合要求则标记为2，且入栈*/
    Push(tempPoint);

    FootPrints[row][col].row = p.row;/*记录上一个点的坐标*/
    FootPrints[row][col].col = p.col;
    //FootPrints[row][col] = p;
}

void Print_Maze(void)
{
    int i = 0, j = 0;

    for(i = 0; i < MAX_ROW; i++)
    {
        for(j = 0; j < MAX_COL; j++)
        {
            printf("%2d", maze[i][j]);
        }
        
        printf("\n");
    }

    printf("\n*****************************************  \n");
}

void Print_Foots(Point p)
{
    printf("{%d, %d} \n", p.row, p.col);
    while(FootPrints[p.row][p.col].row != -1)/*FootPrints[p.row][p.col]记录p点的上一个点的坐标*/
    {
        p = FootPrints[p.row][p.col];
        printf("{%d, %d} \n", p.row, p.col);/*倒序打印走出 迷宫的每一个点坐标*/
    }

    printf("seccess out ! \n");
}

int main(void)
{
    Point p = {0, 0};/*出发点*/

    maze[p.row][p.col] = 2;/*访问过的点标记为2*/
    Push(p);/*把出发入栈*/

    while(! StackEmpty())
    {
        p = Pop();/*出栈，找当前点的下一个可访问点*/

        if((p.row+1 == MAX_ROW) && (p.col+1 == MAX_COL))/*找到出口马上退出*/
        {
            printf("it's go out ! \n");
            break;
        }
        
        if((p.row+1 < MAX_ROW) && (maze[p.row+1][p.col] == 0))
        {
            VisitedPoint(p.row+1, p.col, p);
        }

        if((p.col+1 < MAX_COL) && (maze[p.row][p.col+1] == 0))
        {
            VisitedPoint(p.row, p.col+1, p);
        }

        if((p.row-1 >= 0) && (maze[p.row-1][p.col] == 0))
        {
            VisitedPoint(p.row-1, p.col, p);
        }

        if((p.col-1 >= 0) && (maze[p.row][p.col-1] == 0))
        {
            VisitedPoint(p.row, p.col-1, p);
        }

        Print_Maze();/*打印迷宫*/
    }


    if((p.row+1 == MAX_ROW) && (p.col+1 == MAX_COL))
    {
        Print_Foots(p);/*打印成功走出迷宫的路径*/
    }
    else
    {
        printf("No Path ! \n");
    }

    return    0;

}

/**************************************************************************
    打印结果可以看出这种搜索算法的特点是：每次探索完各个方向相邻的点之后，
取其中一个相邻的点走下去，一直走到无路可走了再退回来，取另一个相邻的点
再走下去。这称为深度优先搜索（DFS，Depth First Search）。
*******************************************************************/